package cn.itcast.service.impl;

import cn.itcast.dao.IPersonDao;
import cn.itcast.domain.Person;
import cn.itcast.service.IPersonService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.util.List;

@Service("personService")
public class PersonServiceImpl implements IPersonService {

    @Autowired
    private IPersonDao personDao;

    @Autowired
    RedisTemplate redisTemplate;
    /**
     * 查询所有捐赠者
     * @return
     */
    @Override
    public List<Person> findAllDonators() {
        List<Person> personList =  personDao.findAllDonator();
        //将捐赠者信息放入redis缓存
        for(Person person : personList){
            redisTemplate.opsForHash().put("donator",person.getId().toString(),person);
        }
        return personList;
    }

    /**
     * 插入捐赠者
     * @param name
     */
    @Override
    public String insertDonator(String name) {
        // 查询该捐赠者是否已存在
        String donatorId = this.findDonatorByName(name);
        if(donatorId.equals("0")){
            // 若不存在，则插入该捐赠者，并重新获取其id
            personDao.insertDonator(name);
            donatorId = this.findDonatorByName(name);
        } else{
            // 若已存在，则不做处理
        }
        //在redis缓存中插入捐赠者
        redisTemplate.opsForHash().put("donator",donatorId,personDao.findDonatorById(donatorId));
        return donatorId;
    }

    /**
     * 更新捐赠者
     * @param donator
     */
    @Override
    public void updateDonator(Person donator) {
        personDao.updateDonator(donator);
        //更新redis缓存
        redisTemplate.opsForHash().put("donator",donator.getId(),donator);
    }

    /**
     * 删除捐赠者
     * @param id
     */
    @Override
    public void deleteDonatorById(String id) {
        personDao.deleteDonatorById(id);
        //在redis缓存中删除捐赠者
        redisTemplate.opsForHash().delete("donator",id);
    }

    /**
     * 根据捐赠者名字查找id
     * @param name
     * @return
     */
    @Override
    public String findDonatorByName(String name) {
        // 在donator表中根据名字查找捐赠者id
        String id = personDao.findDonatorByName(name);
        if(id != null){
            // 若id存在，则返回id
            return id;
        } else{
            // 若id不存在，则返回"0"
            return "0";
        }
    }

    /**
     * 根据id查找捐赠者
     * @param id
     * @return
     */
    @Override
    public Person findDonatorById(String id) {
        Person donator;
        if(redisTemplate.opsForHash().hasKey("donator",id)){
            //若redis缓存中含有该捐赠者
            donator = (Person) redisTemplate.opsForHash().get("donator",id);
        } else{
            //若redis缓存中不含该捐赠者,则从mysql中获取
            donator = personDao.findDonatorById(id);
            //将捐赠者放入reids缓存
            redisTemplate.opsForHash().put("donator",id,donator);
        }
        return donator;
    }

    /**
     * 查询所有接收者
     * @return
     */
    @Override
    public List<Person> findAllReciever() {
        List<Person> personList =  personDao.findAllReciever();
        for(Person person : personList){
            //将接收者信息放入redis缓存
            redisTemplate.opsForHash().put("reciever",person.getId().toString(),person);
        }
        return personList;
    }

    /**
     * 插入接收者
     * @param name
     * @return
     */
    @Override
    public String insertReciever(String name) {
        // 查询该接收者是否已存在
        String recieverId = this.findRecieverByName(name);
        if(recieverId.equals("0")){
            // 若不存在，则插入该捐赠者，并重新获取其id返回
            personDao.insertReciever(name);
            recieverId = this.findRecieverByName(name);
        } else{
            // 若已存在，不做处理
        }
        ////在redis缓存中插入接收者
        redisTemplate.opsForHash().put("recievor",recieverId,personDao.findRecieverById(recieverId));
        return recieverId;
    }

    /**
     * 根据id查找接收者
     * @param id
     * @return
     */
    @Override
    public Person findRecieverById(String id) {
        Person reciever ;
        if(redisTemplate.opsForHash().hasKey("reciever",id)){
            //若redis缓存中含有该接收者
            reciever = (Person) redisTemplate.opsForHash().get("reciever",id);
        } else{
            //若redis缓存中不含有该接收者，从mysql中获取
            reciever = personDao.findRecieverById(id);
            //将接收者信息放入redis缓存
            redisTemplate.opsForHash().put("reciever",id,reciever);
        }
        return reciever;
    }

    /**
     * 更新接收者
     * @param reciever
     */
    @Override
    public void updateReciever(Person reciever) {
        personDao.updateReciever(reciever);
        //更新redis缓存
        redisTemplate.opsForHash().put("reciever",reciever.getId(),reciever);
    }

    /**
     * 根据id删除接收者
     * @param id
     */
    @Override
    public void deleteRecieverById(String id) {
        personDao.deleteRecieverById(id);
        //在redis缓存中删除接收者
        redisTemplate.opsForHash().delete("reciever",id);
    }

    /**
     * 根据名字查找接收者
     * @param name
     * @return
     */
    @Override
    public String findRecieverByName(String name) {
        // 在reciever表中根据名字查找接收者id
        String id = personDao.findRecieverByName(name);
        if(id != null){
            // 若id存在，则返回id
            return id;
        } else{
            // 若id不存在，则返回"0"
            return "0";
        }
    }

    /**
     * 模糊查询捐赠者
     * @param key
     * @return
     */
    @Override
    public List<Person> findDonatorByKey(String key) {
        return personDao.findDonatorByKey(key);
    }

    /**
     * 模糊查询接收者
     * @param key
     * @return
     */
    @Override
    public List<Person> findRecieverByKey(String key) {
        return personDao.findRecieverByKey(key);
    }


}
